{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3a44d14d-d9ff-4a32-b478-d3d6f4cde48a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-06T09:07:50.525085Z",
     "iopub.status.busy": "2023-11-06T09:07:50.524408Z",
     "iopub.status.idle": "2023-11-06T09:07:53.540427Z",
     "shell.execute_reply": "2023-11-06T09:07:53.539049Z",
     "shell.execute_reply.started": "2023-11-06T09:07:50.525043Z"
    },
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using backend: paddle\r\n",
      "Other available backends: tensorflow.compat.v1, tensorflow, pytorch, jax.\r\n",
      "paddle supports more examples now and is recommended.\r\n",
      " \r\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib  \n",
    "from matplotlib import pyplot as plt\n",
    "import deepxde as dde\n",
    "import os\n",
    "\n",
    "main_path = os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "15528d0e-3f70-4791-9203-1a2389617f63",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-06T09:07:55.331175Z",
     "iopub.status.busy": "2023-11-06T09:07:55.330096Z",
     "iopub.status.idle": "2023-11-06T09:07:56.412932Z",
     "shell.execute_reply": "2023-11-06T09:07:56.411315Z",
     "shell.execute_reply.started": "2023-11-06T09:07:55.331136Z"
    },
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set the default float type to float32\r\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning: CSGDifference.uniform_points not implemented. Use random_points instead.\r\n",
      "[11522, 11522, 11522, 11522]\r\n",
      "11522\r\n"
     ]
    }
   ],
   "source": [
    "# 需要对哪个level的网格进行加密？\n",
    "level = 3\n",
    "\n",
    "\"\"\"------------------------------ Fluid parameters  -----------------------\"\"\"\n",
    "# The universal gas constant 气体常数 (FOR AIR HERE)\n",
    "R = 286.9 #(J/Kg.K)\n",
    "\n",
    "# 空气绝热指数\n",
    "k = 1.4\n",
    "\n",
    "# 用于无量纲化的速度、压力和密度，取入口处的声速值、压力值和密度值\n",
    "p0 = 73048 #(pa)\n",
    "rho0 = 0.9 #(kg/m^3)\n",
    "a0 = np.sqrt(k*p0/rho0) #(m/s)\n",
    "\n",
    "\"\"\"------------------------------ NACA633418 shape -----------------------\"\"\"\n",
    "airfoil_boundary_points = np.load('../0_Mesh_files/ordered_airfoil_points.npy')[:, 0:2]\n",
    "airfoil = dde.geometry.Polygon(airfoil_boundary_points)\n",
    "\n",
    "\"\"\"------------------------------------ Training Spatio-temporal region --------------------------------------\"\"\"\n",
    "\"\"\"-------------- Rectangular -------------\"\"\"\n",
    "x_min, x_max = -5.5, 6.5\n",
    "L = x_max - x_min\n",
    "\n",
    "y_min, y_max = -2.0, 2.0\n",
    "H = y_max - y_min\n",
    "\n",
    "\"\"\"Spatial region definition\"\"\"\n",
    "farfield = dde.geometry.Rectangle([x_min, y_min], [x_max, y_max])  # 设置左下角和右上角坐标\n",
    "geom = dde.geometry.CSGDifference(farfield, airfoil)\n",
    "\n",
    "\"\"\"------------------------------ Navier Stokes Equation(Time-dependent PDE) -----------------------\"\"\"\n",
    "def DL_Euler_Equation_2D(x, y):\n",
    "    \"\"\"\n",
    "    System of PDEs to be minimized: compressible 2D Euler equations.\n",
    "\n",
    "    \"\"\"\n",
    "    gamma = 1.4\n",
    "    \n",
    "    u = y[:, 0:1]\n",
    "    v = y[:, 1:2]\n",
    "    p = y[:, 2:3]\n",
    "    rho = y[:, 3:4]\n",
    "\n",
    "    E = p/(gamma-1) + 0.5*rho*(u*u + v*v)\n",
    "\n",
    "    A1, B1 = rho*u, rho*v\n",
    "    A2, B2 = gamma*rho*u*u + p, gamma*rho*u*v\n",
    "    A3, B3 = gamma*rho*u*v, gamma*rho*v*v + p\n",
    "    A4, B4 = u*E, v*E\n",
    "\n",
    "    dA1_x = dde.grad.jacobian(A1, x, i=0, j=0)\n",
    "    dB1_y = dde.grad.jacobian(B1, x, i=0, j=1)\n",
    "\n",
    "    dA2_x = dde.grad.jacobian(A2, x, i=0, j=0)\n",
    "    dB2_y = dde.grad.jacobian(B2, x, i=0, j=1)\n",
    "\n",
    "    dA3_x = dde.grad.jacobian(A3, x, i=0, j=0)\n",
    "    dB3_y = dde.grad.jacobian(B3, x, i=0, j=1)\n",
    "\n",
    "    dA4_x = dde.grad.jacobian(A4, x, i=0, j=0)\n",
    "    dB4_y = dde.grad.jacobian(B4, x, i=0, j=1)\n",
    "    \n",
    "    continuity = dA1_x + dB1_y\n",
    "    x_momentum = dA2_x + dB2_y\n",
    "    y_momentum = dA3_x + dB3_y\n",
    "    energy = dA4_x + dB4_y\n",
    "    return [continuity, x_momentum, y_momentum, energy]\n",
    "\n",
    "\"\"\"---------------------------------------- Boundary Definition -------------------------------------------\"\"\"\n",
    "\"\"\"Boundary definition of rectangle domain\"\"\"\n",
    "def boundary_inlet(x, on_boundary):\n",
    "    \"\"\"Checks the inlet boundary\"\"\"\n",
    "    return np.isclose(x[0], x_min)\n",
    "\n",
    "def boundary_outlet(x, on_boundary):\n",
    "    \"\"\"Checks the outlet boundary\"\"\"\n",
    "    return np.isclose(x[0], x_max)\n",
    "\n",
    "def boundary_top_bottom(x, on_boundary):\n",
    "    \"\"\"Checks the bottom boundary\"\"\"\n",
    "    return (np.isclose(x[1], y_min) or np.isclose(x[1], y_max))\n",
    "\n",
    "\"\"\"Boundary definition of cylinder domain\"\"\"\n",
    "def boundary_airfoil(x, on_boundary):\n",
    "    return on_boundary and (not farfield.on_boundary(x))\n",
    "\n",
    "'''-----------------------Defining BC for u, v, and p (component = 0, 1, 2 resp assign)---------------------------\n",
    "------------------------------\n",
    "Dirichlet boundary conditions:\n",
    "    y(x) = func(x)\n",
    "------------------------------\n",
    "Neumann boundary conditions: \n",
    "    dy/dn(x) = func(x)\n",
    "------------------------------'''\n",
    "# Boundary values definition\n",
    "def No_slip(x): # 无滑移\n",
    "    return 0.0\n",
    "\n",
    "def uniform_flow(x): # 无滑移\n",
    "    return 0.7\n",
    "\n",
    "def Zero_v(x):  # 零速度\n",
    "    return 0.0\n",
    "\n",
    "def Zero_p(x):  # 零压力\n",
    "    return 0.0\n",
    "\n",
    "'''----------------------- Other functions ---------------------------'''\n",
    "def gen_training_points():\n",
    "    mesh_xy_points = data_points[:, 0:2]\n",
    "    return mesh_xy_points\n",
    "\n",
    "def plot_points_xy(points, color=\"k\", marker=\".\"):\n",
    "    figure = plt.figure()\n",
    "    axis = figure.add_subplot(111)\n",
    "    axis.scatter(points[:, 0], points[:, 1], s=0.5, color=color, marker=marker)\n",
    "    plt.axis(\"scaled\")  # 设置x轴和y轴相同的缩放比例\n",
    "    plt.savefig('./Figs/Total_points.png', dpi=300)\n",
    "    plt.show()\n",
    "    \n",
    "\n",
    "def plot_flow_field():\n",
    "    import matplotlib as mpl\n",
    "    from matplotlib import rcParams\n",
    "    config = {\"font.size\": 16}\n",
    "    rcParams.update(config)\n",
    "    plt.rcParams['xtick.direction'] = 'in'\n",
    "    plt.rcParams['ytick.direction'] = 'in'\n",
    "    '''------------------------------------------- Model validation ---------------------------------------------'''\n",
    "    '''------------------Plotting 2------------------'''\n",
    "\n",
    "    test_data = data_xy\n",
    "\n",
    "    # Model predictions generation\n",
    "    u = model.predict(test_data)[:, 0] * a0\n",
    "    v = model.predict(test_data)[:, 1] * a0\n",
    "    p = model.predict(test_data)[:, 2] * p0\n",
    "    rho = model.predict(test_data)[:, 3] * rho0\n",
    "\n",
    "    airfoil_plot = airfoil_boundary_points[:, 0:2]\n",
    "\n",
    "    # plot\n",
    "    fig, ax = plt.subplots(figsize=(10, 4))\n",
    "    ax.tricontourf(data_xy[:, 0], data_xy[:, 1], (u**2 + v**2)**0.5, levels=1000, cmap=\"coolwarm\", vmin=36.5, vmax=467)\n",
    "    plt.axis('scaled')\n",
    "    plt.fill(airfoil_plot[:, 0], airfoil_plot[:, 1], color = 'w')\n",
    "    norm =mpl.colors.Normalize(vmin=36.5, vmax=467)\n",
    "    plt.rcParams['ytick.direction'] = 'out'\n",
    "    plt.colorbar(mpl.cm.ScalarMappable(norm=norm, cmap=\"coolwarm\"), ax=ax, label='[m/s]')\n",
    "    plt.rcParams['ytick.direction'] = 'in'    \n",
    "    plt.xlabel('x')\n",
    "    plt.ylabel('y')\n",
    "    plt.title('Velocity Magnitude')\n",
    "    plt.savefig(\"./Figs/Velocity.png\", dpi=300)\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "    fig, ax = plt.subplots(figsize=(10, 4))\n",
    "    ax.tricontourf(data_xy[:, 0], data_xy[:, 1], p, levels=1000, cmap=\"coolwarm\", vmin=19900, vmax=100000)\n",
    "    plt.axis('scaled')\n",
    "    plt.fill(airfoil_plot[:, 0], airfoil_plot[:, 1], color = 'w')\n",
    "    norm =mpl.colors.Normalize(vmin=19900, vmax=100000)\n",
    "    plt.rcParams['ytick.direction'] = 'out'\n",
    "    plt.colorbar(mpl.cm.ScalarMappable(norm=norm, cmap=\"coolwarm\"), ax=ax, label='[Pa]')\n",
    "    plt.rcParams['ytick.direction'] = 'in'    \n",
    "    plt.xlabel('x')\n",
    "    plt.ylabel('y')\n",
    "    plt.title('Pressure')\n",
    "    plt.savefig(\"./Figs/P.png\", dpi=300)\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "    \n",
    "    fig, ax = plt.subplots(figsize=(10, 4))\n",
    "    ax.tricontourf(data_xy[:, 0], data_xy[:, 1], rho, levels=1000, cmap=\"coolwarm\", vmin=0.341, vmax=1.13)\n",
    "    plt.axis('scaled')\n",
    "    plt.fill(airfoil_plot[:, 0], airfoil_plot[:, 1], color = 'w')\n",
    "    norm =mpl.colors.Normalize(vmin=0.341, vmax=1.13)\n",
    "    plt.rcParams['ytick.direction'] = 'out'\n",
    "    plt.colorbar(mpl.cm.ScalarMappable(norm=norm, cmap=\"coolwarm\"), ax=ax, label='[kg/m^3]')\n",
    "    plt.rcParams['ytick.direction'] = 'in'    \n",
    "    plt.xlabel('x')\n",
    "    plt.ylabel('y')\n",
    "    plt.title('Density')\n",
    "    plt.savefig(\"./Figs/Rho.png\", dpi=300)\n",
    "    plt.show()\n",
    "    \n",
    "     \n",
    "\n",
    "def make_dir():\n",
    "    # 保存训练结果需要的文件\n",
    "    # 模型保存地址\n",
    "    Model_path = \"Model/\"  \n",
    "    # 图片保存地址\n",
    "    Figs_path = \"Figs/\"  \n",
    "    # Loss保存地址\n",
    "    Train_history_path = \"Train_history/\"  \n",
    "\n",
    "    if not os.path.exists(Model_path):\n",
    "    \tos.mkdir(Model_path)\n",
    "    if not os.path.exists(Figs_path):\n",
    "    \tos.mkdir(Figs_path)\n",
    "    if not os.path.exists(Train_history_path):\n",
    "    \tos.mkdir(Train_history_path)\n",
    "\n",
    "def plot_loss_history(loss_history, fname=None):\n",
    "    loss_train = np.sum(loss_history.loss_train, axis=1)\n",
    "    loss_test = np.sum(loss_history.loss_test, axis=1)\n",
    "\n",
    "    plt.figure()\n",
    "    plt.semilogy(loss_history.steps, loss_train, label=\"Train loss\")\n",
    "    plt.semilogy(loss_history.steps, loss_test, label=\"Test loss\")\n",
    "    for i in range(len(loss_history.metrics_test[0])):\n",
    "        plt.semilogy(\n",
    "            loss_history.steps,\n",
    "            np.array(loss_history.metrics_test)[:, i],\n",
    "            label=\"Test metric\",\n",
    "        )\n",
    "    plt.xlabel(\"# Steps\")\n",
    "    plt.legend()\n",
    "\n",
    "    if isinstance(fname, str):\n",
    "        plt.savefig(fname, dpi=500)\n",
    "\n",
    "\n",
    "\n",
    "'''-------------------------------------------------------------- training model:  ------------------------------------------------------------------'''\n",
    "dde.config.set_random_seed(1234)\n",
    "dde.config.set_default_float(\"float32\")\n",
    "\n",
    "make_dir()\n",
    "\n",
    "'''------------------BC------------------'''\n",
    "# 合理的远场边界条件\n",
    "bc_inlet_u = dde.DirichletBC(geom, uniform_flow, boundary_inlet, component = 0)\n",
    "bc_inlet_v = dde.DirichletBC(geom, Zero_v, boundary_inlet, component = 1)\n",
    "\n",
    "bc_outlet_p = dde.DirichletBC(geom, Zero_p, boundary_outlet, component = 2)\n",
    "\n",
    "bc_top_bottom_u =  dde.DirichletBC(geom, uniform_flow, boundary_top_bottom, component = 0)\n",
    "bc_top_bottom_v =  dde.DirichletBC(geom, Zero_v, boundary_top_bottom, component = 1)\n",
    "\n",
    "bc_airfoil_u = dde.DirichletBC(geom, No_slip, boundary_airfoil, component = 0)\n",
    "bc_airfoil_v = dde.DirichletBC(geom, No_slip, boundary_airfoil, component = 1)\n",
    "\n",
    "# 翼型边界条件\n",
    "foil_xy, foil_u, foil_v = airfoil_boundary_points[:, 0:2], np.zeros_like(airfoil_boundary_points[:, 0:1]), np.zeros_like(airfoil_boundary_points[:, 0:1])\n",
    "bc_airfoil2_u = dde.icbc.PointSetBC(foil_xy, foil_u, component = 0)\n",
    "bc_airfoil2_v = dde.icbc.PointSetBC(foil_xy, foil_v, component = 1)\n",
    "\n",
    "# data\n",
    "data_points = np.load('../1_Fluent_results/level' + str(level) + '_fluent_results.npy')\n",
    "\n",
    "# 此处注意无量纲化\n",
    "data_xy = data_points[:, 0:2]\n",
    "data_u = data_points[:, 2:3]/a0\n",
    "data_v = data_points[:, 3:4]/a0\n",
    "data_p = data_points[:, 4:5]/p0\n",
    "data_rho = data_points[:, 5:6]/rho0\n",
    "\n",
    "data_u = dde.icbc.PointSetBC(data_xy, data_u, component = 0)\n",
    "data_v = dde.icbc.PointSetBC(data_xy, data_v, component = 1)\n",
    "data_p = dde.icbc.PointSetBC(data_xy, data_p, component = 2)\n",
    "data_rho = dde.icbc.PointSetBC(data_xy, data_rho, component = 3)\n",
    "\n",
    "bcs = [\n",
    "      data_u,\n",
    "      data_v,\n",
    "      data_p,\n",
    "      data_rho,\n",
    "]\n",
    "'''--------------- Training Model ----------------'''\n",
    "# 根据目前的geomtime生成训练点\n",
    "total_points = gen_training_points()\n",
    "plot_points_xy(total_points)\n",
    "\n",
    "'''----Training datasets and Loss function ----'''\n",
    "data = dde.data.PDE(geom,\n",
    "              DL_Euler_Equation_2D, # Loss function\n",
    "              bcs,                 # IC and BC\n",
    "              num_domain = 0,      # training data\n",
    "              num_boundary = 0,     # boundary data\n",
    "              num_test = 1000,         # test data\n",
    "              anchors = total_points,\n",
    "              )         \n",
    "print(data.num_bcs)\n",
    "print(data.train_x_all.shape[0])\n",
    "\n",
    "'''--------- Neural Network setup ---------'''\n",
    "layer_size = [2] + [40] * 6 + [4]\n",
    "activation = \"tanh\"\n",
    "initializer = \"Glorot uniform\"\n",
    "net = dde.nn.FNN(layer_size, activation, initializer)\n",
    "\n",
    "'''-------- Compile, Training and save Model --------'''\n",
    "model = dde.Model(data, net)\n",
    "weights = [1] * 4 + [10] * 4\n",
    "\n",
    "# first use Adam to find a roughly good solution, \n",
    "# model.compile(\"adam\", lr=1e-3, loss_weights = weights)\n",
    "# loss_history, train_state = model.train(epochs=20000, display_every=100)\n",
    "# plot_loss_history(loss_history, \"./Train_history/Loss.png\")\n",
    "# dde.saveplot(loss_history, train_state, issave=True, isplot=True, output_dir = \"./Train_history\")\n",
    "# model.save(save_path=\"./Model/model\")\n",
    "# plot_flow_field()\n",
    "\n",
    "# model.compile(\"adam\", lr=5e-4, loss_weights = weights)\n",
    "# loss_history, train_state = model.train(epochs=20000, display_every=100)\n",
    "# plot_loss_history(loss_history, \"./Train_history/Loss.png\")\n",
    "# dde.saveplot(loss_history, train_state, issave=True, isplot=True, output_dir = \"./Train_history\")\n",
    "# model.save(save_path=\"./Model/model\")\n",
    "# plot_flow_field()\n",
    "\n",
    "# model.compile(\"adam\", lr=1e-4, loss_weights = weights)\n",
    "# loss_history, train_state = model.train(epochs=20000, display_every=100)\n",
    "# plot_loss_history(loss_history, \"./Train_history/Loss.png\")\n",
    "# dde.saveplot(loss_history, train_state, issave=True, isplot=True, output_dir = \"./Train_history\")\n",
    "# model.save(save_path=\"./Model/model\")\n",
    "# plot_flow_field()\n",
    "\n",
    "# and then use L-BFGS to search a local minimum.\n",
    "# model.compile(optimizer=\"L-BFGS\", loss_weights = weights)\n",
    "# # Optional: Save the model during training.\n",
    "# checkpointer = dde.callbacks.ModelCheckpoint(\"Model/model\", verbose=1000, save_better_only=True)\n",
    "# loss_history, train_state = model.train(display_every=100, model_restore_path = \"../../level2/2_PINN_training/Model/model-15000.pdparams\", callbacks=[checkpointer])\n",
    "# plot_loss_history(loss_history, \"./Train_history/Loss.png\")\n",
    "# dde.saveplot(loss_history, train_state, issave=True, isplot=True, output_dir = \"./Train_history\")\n",
    "# model.save(save_path=\"./Model/model\")\n",
    "# plot_flow_field()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4249ff50-f66f-41ff-b7a9-180934937dc1",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-11-06T09:08:01.608830Z",
     "iopub.status.busy": "2023-11-06T09:08:01.607051Z",
     "iopub.status.idle": "2023-11-06T09:08:09.468687Z",
     "shell.execute_reply": "2023-11-06T09:08:09.466630Z",
     "shell.execute_reply.started": "2023-11-06T09:08:01.608769Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Compiling model...\r\n",
      "'compile' took 0.000437 s\r\n",
      "\r\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model.compile(optimizer=\"L-BFGS\", loss_weights = weights)\n",
    "model.restore(save_path=\"./Model/model-75000.pdparams\")\n",
    "plot_flow_field()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b1c579c-3ba9-4745-93e3-502d173c1bb4",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "py35-paddle1.2.0"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
